home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / symtable.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  11KB  |  315 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """Interface to the compiler's internal symbol tables"""
  5. import _symtable
  6. from _symtable import USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM, DEF_STAR, DEF_DOUBLESTAR, DEF_INTUPLE, DEF_FREE, DEF_FREE_GLOBAL, DEF_FREE_CLASS, DEF_IMPORT, DEF_BOUND, OPT_IMPORT_STAR, OPT_EXEC, OPT_BARE_EXEC
  7. import weakref
  8. __all__ = [
  9.     'symtable',
  10.     'SymbolTable',
  11.     'newSymbolTable',
  12.     'Class',
  13.     'Function',
  14.     'Symbol']
  15.  
  16. def symtable(code, filename, compile_type):
  17.     raw = _symtable.symtable(code, filename, compile_type)
  18.     return newSymbolTable(raw[0], filename)
  19.  
  20.  
  21. class SymbolTableFactory:
  22.     
  23.     def __init__(self):
  24.         self._SymbolTableFactory__memo = weakref.WeakValueDictionary()
  25.  
  26.     
  27.     def new(self, table, filename):
  28.         if table.type == _symtable.TYPE_FUNCTION:
  29.             return Function(table, filename)
  30.         
  31.         if table.type == _symtable.TYPE_CLASS:
  32.             return Class(table, filename)
  33.         
  34.         return SymbolTable(table, filename)
  35.  
  36.     
  37.     def __call__(self, table, filename):
  38.         key = (table, filename)
  39.         obj = self._SymbolTableFactory__memo.get(key, None)
  40.         if obj is None:
  41.             obj = self._SymbolTableFactory__memo[key] = self.new(table, filename)
  42.         
  43.         return obj
  44.  
  45.  
  46. newSymbolTable = SymbolTableFactory()
  47.  
  48. def is_free(flags):
  49.     if flags & (USE | DEF_FREE) and flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL):
  50.         return True
  51.     
  52.     if flags & DEF_FREE_CLASS:
  53.         return True
  54.     
  55.     return False
  56.  
  57.  
  58. class SymbolTable:
  59.     
  60.     def __init__(self, raw_table, filename):
  61.         self._table = raw_table
  62.         self._filename = filename
  63.         self._symbols = { }
  64.  
  65.     
  66.     def __repr__(self):
  67.         if self.__class__ == SymbolTable:
  68.             kind = ''
  69.         else:
  70.             kind = '%s ' % self.__class__.__name__
  71.         if self._table.name == 'global':
  72.             return '<%sSymbolTable for module %s>' % (kind, self._filename)
  73.         else:
  74.             return '<%sSymbolTable for %s in %s>' % (kind, self._table.name, self._filename)
  75.  
  76.     
  77.     def get_type(self):
  78.         if self._table.type == _symtable.TYPE_MODULE:
  79.             return 'module'
  80.         
  81.         if self._table.type == _symtable.TYPE_FUNCTION:
  82.             return 'function'
  83.         
  84.         if self._table.type == _symtable.TYPE_CLASS:
  85.             return 'class'
  86.         
  87.         if not self._table.type in (1, 2, 3):
  88.             raise AssertionError, 'unexpected type: %s' % self._table.type
  89.  
  90.     
  91.     def get_id(self):
  92.         return self._table.id
  93.  
  94.     
  95.     def get_name(self):
  96.         return self._table.name
  97.  
  98.     
  99.     def get_lineno(self):
  100.         return self._table.lineno
  101.  
  102.     
  103.     def is_optimized(self):
  104.         if self._table.type == _symtable.TYPE_FUNCTION:
  105.             pass
  106.         return bool(not (self._table.optimized))
  107.  
  108.     
  109.     def is_nested(self):
  110.         return bool(self._table.nested)
  111.  
  112.     
  113.     def has_children(self):
  114.         return bool(self._table.children)
  115.  
  116.     
  117.     def has_exec(self):
  118.         '''Return true if the scope uses exec'''
  119.         return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC))
  120.  
  121.     
  122.     def has_import_star(self):
  123.         '''Return true if the scope uses import *'''
  124.         return bool(self._table.optimized & OPT_IMPORT_STAR)
  125.  
  126.     
  127.     def get_identifiers(self):
  128.         return self._table.symbols.keys()
  129.  
  130.     
  131.     def lookup(self, name):
  132.         sym = self._symbols.get(name)
  133.         if sym is None:
  134.             flags = self._table.symbols[name]
  135.             namespaces = self._SymbolTable__check_children(name)
  136.             sym = self._symbols[name] = Symbol(name, flags, namespaces)
  137.         
  138.         return sym
  139.  
  140.     
  141.     def get_symbols(self):
  142.         return [ self.lookup(ident) for ident in self.get_identifiers() ]
  143.  
  144.     
  145.     def __check_children(self, name):
  146.         return _[1]
  147.  
  148.     
  149.     def get_children(self):
  150.         return [ newSymbolTable(st, self._filename) for st in self._table.children ]
  151.  
  152.  
  153.  
  154. class Function(SymbolTable):
  155.     __params = None
  156.     __locals = None
  157.     __frees = None
  158.     __globals = None
  159.     
  160.     def __idents_matching(self, test_func):
  161.         return [](_[1])
  162.  
  163.     
  164.     def get_parameters(self):
  165.         if self._Function__params is None:
  166.             self._Function__params = self._Function__idents_matching((lambda x: x & DEF_PARAM))
  167.         
  168.         return self._Function__params
  169.  
  170.     
  171.     def get_locals(self):
  172.         if self._Function__locals is None:
  173.             self._Function__locals = self._Function__idents_matching((lambda x: x & DEF_BOUND))
  174.         
  175.         return self._Function__locals
  176.  
  177.     
  178.     def get_globals(self):
  179.         if self._Function__globals is None:
  180.             glob = DEF_GLOBAL | DEF_FREE_GLOBAL
  181.             self._Function__globals = self._Function__idents_matching((lambda x: x & glob))
  182.         
  183.         return self._Function__globals
  184.  
  185.     
  186.     def get_frees(self):
  187.         if self._Function__frees is None:
  188.             self._Function__frees = self._Function__idents_matching(is_free)
  189.         
  190.         return self._Function__frees
  191.  
  192.  
  193.  
  194. class Class(SymbolTable):
  195.     __methods = None
  196.     
  197.     def get_methods(self):
  198.         if self._Class__methods is None:
  199.             d = { }
  200.             for st in self._table.children:
  201.                 d[st.name] = 1
  202.             
  203.             self._Class__methods = tuple(d)
  204.         
  205.         return self._Class__methods
  206.  
  207.  
  208.  
  209. class Symbol:
  210.     
  211.     def __init__(self, name, flags, namespaces = None):
  212.         self._Symbol__name = name
  213.         self._Symbol__flags = flags
  214.         if not namespaces:
  215.             pass
  216.         self._Symbol__namespaces = ()
  217.  
  218.     
  219.     def __repr__(self):
  220.         return "<symbol '%s'>" % self._Symbol__name
  221.  
  222.     
  223.     def get_name(self):
  224.         return self._Symbol__name
  225.  
  226.     
  227.     def is_referenced(self):
  228.         return bool(self._Symbol__flags & _symtable.USE)
  229.  
  230.     
  231.     def is_parameter(self):
  232.         return bool(self._Symbol__flags & DEF_PARAM)
  233.  
  234.     
  235.     def is_global(self):
  236.         if not self._Symbol__flags & DEF_GLOBAL:
  237.             pass
  238.         return bool(self._Symbol__flags & DEF_FREE_GLOBAL)
  239.  
  240.     
  241.     def is_vararg(self):
  242.         return bool(self._Symbol__flags & DEF_STAR)
  243.  
  244.     
  245.     def is_keywordarg(self):
  246.         return bool(self._Symbol__flags & DEF_DOUBLESTAR)
  247.  
  248.     
  249.     def is_local(self):
  250.         return bool(self._Symbol__flags & DEF_BOUND)
  251.  
  252.     
  253.     def is_free(self):
  254.         if self._Symbol__flags & (USE | DEF_FREE) and self._Symbol__flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL):
  255.             return True
  256.         
  257.         if self._Symbol__flags & DEF_FREE_CLASS:
  258.             return True
  259.         
  260.         return False
  261.  
  262.     
  263.     def is_imported(self):
  264.         return bool(self._Symbol__flags & DEF_IMPORT)
  265.  
  266.     
  267.     def is_assigned(self):
  268.         return bool(self._Symbol__flags & DEF_LOCAL)
  269.  
  270.     
  271.     def is_in_tuple(self):
  272.         return bool(self._Symbol__flags & DEF_INTUPLE)
  273.  
  274.     
  275.     def is_namespace(self):
  276.         '''Returns true if name binding introduces new namespace.
  277.  
  278.         If the name is used as the target of a function or class
  279.         statement, this will be true.
  280.  
  281.         Note that a single name can be bound to multiple objects.  If
  282.         is_namespace() is true, the name may also be bound to other
  283.         objects, like an int or list, that does not introduce a new
  284.         namespace.
  285.         '''
  286.         return bool(self._Symbol__namespaces)
  287.  
  288.     
  289.     def get_namespaces(self):
  290.         '''Return a list of namespaces bound to this name'''
  291.         return self._Symbol__namespaces
  292.  
  293.     
  294.     def get_namespace(self):
  295.         '''Returns the single namespace bound to this name.
  296.  
  297.         Raises ValueError if the name is bound to multiple namespaces.
  298.         '''
  299.         if len(self._Symbol__namespaces) != 1:
  300.             raise ValueError, 'name is bound to multiple namespaces'
  301.         
  302.         return self._Symbol__namespaces[0]
  303.  
  304.  
  305. if __name__ == '__main__':
  306.     import os
  307.     import sys
  308.     src = open(sys.argv[0]).read()
  309.     mod = symtable(src, os.path.split(sys.argv[0])[1], 'exec')
  310.     for ident in mod.get_identifiers():
  311.         info = mod.lookup(ident)
  312.         print info, info.is_local(), info.is_namespace()
  313.     
  314.  
  315.